/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package pkgPrincipal;

import java.awt.Font;
import java.util.ArrayList;
import jgame.JGColor;
import jgame.JGFont;
import jgame.JGObject;
import jgame.JGTimer;


import jgame.platform.JGEngine;

/**
 *
 * @author Gravufo, Mike, Nejteh
 */
public class Jeu extends JGEngine
{

    /**
     * Variable qui nous permet de controler le personnage principal
     */
    private Mouton mouton;
    /**
     * Mouton a utiliser dans le tutoriel
     */
    private Mouton moutonTutoriel;
    /**
     * Object utiliser dans le menu ou le tutoriel
     */
    private JGObject btnJouer;
    /**
     * Object utiliser dans le menu ou le tutoriel
     */
    private JGObject btnTutoriel;
    /**
     * Object utiliser dans le menu ou le tutoriel
     */
    private JGObject btnMenu;
    /**
     * Object utiliser dans le menu ou le tutoriel
     */
    private JGObject btnDroit;
    /**
     * Object utiliser dans le menu ou le tutoriel
     */
    private JGObject btnGauche;
    /**
     * Object utiliser dans le menu ou le tutoriel
     */
    private JGObject plateforme;
    /**
     * Monstre utilise dans le tutoriel
     */
    private Monstre monstre1;
    /**
     * Monstre utilise dans le tutoriel
     */
    private Monstre monstre2;
    /**
     * Bullet utiliser dans le tutoriel
     */
    private Bullet bullet;
    /**
     * Contient le offset en x. Egal a 0, car on bouge juste en y
     */
    private final int xOfs = 0;
    /**
     * contient le nombre de plateformes maximum qui doit être en jeu en tout temps
     */
    private final int MAXPLATEFORMS = 30;
    /**
     * Contient le offset en y. Varie selon la position du mouton
     */
    public static int dernierOffset = 645;
    /**
     * Contient la position Y du dernier offset
     */
    private int yOfs;
    /**
     * Variable contenant le nombre d'objets dans le jeu
     */
    private int objectCount = 0;
    /**
     * Détermine la difficulté du jeu
     */
    private int yDiff = 30;
    /**
     * Détermine la difficulté du jeu
     */
    private int yDiff2 = 90;
    /**
     * Détermine la difficulté du jeu
     */
    private int xPlage = 0;
    /**
     * Détermine la difficulté du jeu
     */
    private int xPlage2;
    /**
     * Détermine la difficulté du jeu
     */
    private int monstreDiff = 40;
    /**
     * Détermine la difficulté du jeu
     */
    private int jetPackDiff = 60;
    /**
     * contient le nombre total de plateforme créé
     */
    private int objectCountTot = 0;
    /**
     * Contient le score present du joueur dans la partie en cours
     */
    private int score = 0;
    /**
     * Position du background en Y
     */
    private int backPosY = -2580 + 645;
    /**
     * Dernier compte d'objets
     */
    private int lastCount = 0;
    /**
     * quel parti du tutoriel on est rendu (1, 2, ou 3)
     */
    private int tutorialState = 1;
    /**
     * compteur pour creer un monstre dans le tutoriel
     */
    private int compteurMonstre = 0;
    /**
     * compteur pour creer des "smoke"
     */
    private int compteurSmoke = 0;
    /**
     * Position de mort du mouton
     */
    private int diePos;
    /**
     * Coordonnee X de la derniere plateforme creee
     */
    private double coordX;
    /**
     * Coordonnee Y de la derniere plateforme creee
     */
    private double coordY;
    /**
     * coordonnee en X aleatoire
     */
    private double xAleatoire;
    /**
     * Vitesse de defilement de l'arriere plan
     */
    private double backScrollSpeed;
    /**
     * Permet de remettre le background a sa position du debut
     */
    private double backMove;
    /**
     * ArrayList qui contient toutes les plateformes du jeu
     */
    private ArrayList<Plateforme> platArray = new ArrayList();
    /**
     * ArrayList qui contient toutes les smokes du jeu
     */
    private ArrayList<Smoke> smokeArray = new ArrayList();
    /**
     * ArrayList qui contient tous les monstres dans le jeu
     */
    private ArrayList<JGObject> monstreArray = new ArrayList();
    /**
     * ArrayList qui contient tous les jetpacks dans le jeu
     */
    private ArrayList<JGObject> jetPackArray = new ArrayList();
    /**
     * ArrayList qui contient tous les jetpacks dans le jeu
     */
    private ArrayList<JGObject> ressortArray = new ArrayList();
    /**
     * ArrayList qui contient tous les bullets dans le jeu
     */
    private ArrayList<Bullet> bulletArray = new ArrayList();
    /**
     * 
     */
    private boolean objets = false;
    /**
     * Determine si le joueur gagne ou perd
     */
    private boolean gagne = true;
    /**
     * Permet de savoir si on cree des monstres/objets speciaux ou non
     */
    private boolean creerObjet = true;
    /**
     * Permet de savoir si l'option audio a changee
     */
    private boolean audioChange;
    /**
     * determine si le son est allume ou eteind
     */
    private boolean audioOn = true;
    /**
     * 
     */
    private boolean continuer = true;
    /**
     * contient le background principal (le premier)
     */
    private Background back;
    /**
     * Contient un grand nombre de backgrounds pour creer un effet "infini"
     */
    private ArrayList<Background> backR = new ArrayList();
//    private String nomJoueur;

    /**
     * Constructeur du jeu
     */
    public Jeu(int largeur, int hauteur)
    {
        // Appel du init de JGame qui appelle automatiquement initCanvas()
        // et initGame()
        initEngine(largeur, hauteur);
    }

    /**
     * Methode appelee automatiquement qui initialise la fenetre
     */
    @Override
    public void initCanvas()
    {
        // Initialisation de la fenetre avec la taille
        setCanvasSettings(1, 1, 400, 645, null, null, null);
    }

    /**
     * Methode appelee automatiquement qui initialise le jeu
     */
    @Override
    public void initGame()
    {
        // On decide de la vitesse de redessinage
        setFrameRate(60, 1);

        // On definit les images qu'on va utiliser dans l'application
        defineImage("background", "-", 0, "GFX/Background.png", "-");
        defineImage("backgroundMenu", "-", 0, "GFX/BackgroundMenu.png", "-");
        defineImage("backR", "-", 0, "GFX/BackgroundRepeat.png", "-");
        defineImage("platform", "-", 0, "GFX/Platform.png", "-");
        defineImage("sheepLeft", "-", 0, "GFX/SheepLeft.png", "-");
        defineImage("sheepRight", "-", 0, "GFX/SheepRight.png", "-");
        defineImage("sheepJetPackLeft", "-", 0, "GFX/SheepJetPackLeft.png", "-");
        defineImage("sheepJetPackRight", "-", 0, "GFX/SheepJetPackRight.png", "-");
        defineImage("sheepDead", "-", 0, "GFX/SheepDead.png", "-");
        defineImage("monster", "-", 0, "GFX/Monster.png", "-");
        defineImage("monsterDead", "-", 0, "GFX/MonsterDead.png", "-");
        defineImage("jetPack", "-", 0, "GFX/JetPack.png", "-");
        defineImage("playButton", "-", 0, "GFX/PlayButton.png", "-");
        defineImage("statsButton", "-", 0, "GFX/StatsButton.png", "-");
        defineImage("tutorialButton", "-", 0, "GFX/TutorialButton.png", "-");
        defineImage("bullet", "-", 0, "GFX/Bullet.png", "-");
        defineImage("spring", "-", 0, "GFX/Spring.png", "-");
        defineImage("springOpen", "-", 0, "GFX/SpringOpen.png", "-");
        defineImage("tutorial1", "-", 0, "GFX/Tutorial1.png", "-");
        defineImage("tutorial2", "-", 0, "GFX/Tutorial2.png", "-");
        defineImage("tutorial3", "-", 0, "GFX/Tutorial3.png", "-");
        defineImage("arrowLeft", "-", 0, "GFX/ArrowLeft.png", "-");
        defineImage("arrowRight", "-", 0, "GFX/ArrowRight.png", "-");
        defineImage("menuButton", "-", 0, "GFX/Menu.png", "-");
        defineImage("smoke", "-", 0, "GFX/Smoke.png", "-");

        // On definit les sons a utiliser durant le jeu
        defineAudioClip("shooting", "SFX/Shooting.wav");
        defineAudioClip("flying", "SFX/Flying.wav");
        defineAudioClip("jump", "SFX/Jump.wav");
        defineAudioClip("monsterDead", "SFX/MonsterDead.wav");
        defineAudioClip("sheepDead", "SFX/SheepDead.wav");
        defineAudioClip("spawn", "SFX/Spawn.wav");
        defineAudioClip("intro", "SFX/Troll.wav");
        defineAudioClip("youLose", "SFX/YouLose.wav");
        defineAudioClip("spring", "SFX/Spring.wav");


        // Permet de commencer l'application sans commencer le jeu
        setGameState("Menu");
    }

    /**
     * Méthode appelée lorsque le game state est changé à "Menu"
     */
    public void startMenu()
    {
        // On applique un arriere-plan pour la page titre
        setBGImage("backgroundMenu");

        // On cree un bouton jouer qu'on affiche sur la page titre
        btnJouer = new JGObject("btnJouer", true, 140, 250, 1, "playButton");
        // btnStats = new JGObject("btnStats", true, 140, 300, 1, "statsButton");
        btnTutoriel = new JGObject("btnTutoriel", true, 140, 350, 1, "tutorialButton");


        new Plateforme(295.0, 625.0, false);
        playAudio("1", "intro", true);

        mouton = new Mouton("aMouton", 320.0, 450.0, Mouton.Direction.sheepRight);
    }

    /**
     * Methode appelee a chaque frame durant le game state "Menu"
     */
    public void doFrameMenu()
    {
        checkCollision(2, 1);
        moveObjects();

        // On verifie si l'utilisateur clique le bouton gauche de la souris
        // afin de commencer le jeu
        if (getMouseButton(1) && getMouseY() >= btnJouer.y && getMouseY()
                <= btnJouer.y + 36 && getMouseX() >= btnJouer.x && getMouseX()
                <= btnJouer.x + 150 || getKey(KeyEnter))
        {
            stopAudio("1");

            // On retire tous les objets dans la fenetre
            removeObjects(null, 0);
            setBGImage(null);

            // On reinitialise la souris
            this.clearMouseButton(1);

            // On reinitialise l'etat de jeu pour ensuite le placer en mode "Started"
            this.clearGameState();
            setGameState("Started");

            // La methode startStarted() est une fois automatiquement.
            // La methode doFrameStarted() est ensuite appelee automatiquement
            // a chaque frame
        }
        else if (getMouseButton(1) && getMouseY() >= btnTutoriel.y && getMouseY()
                <= btnTutoriel.y + 36 && getMouseX() >= btnTutoriel.x
                && getMouseX() <= btnTutoriel.x + 150)
        {
            stopAudio("1");

            // On retire tous les objets dans la fenetre
            removeObjects(null, 0);
            setBGImage(null);

            // On reinitialise la souris
            this.clearMouseButton(1);

            // On reinitialise l'etat de jeu pour ensuite le placer en mode "Tutorial"
            this.clearGameState();
            setGameState("Tutorial");

            // La methode startTutorial() est une fois automatiquement.
            // La methode doFrameTutorial() est ensuite appelee automatiquement
            // a chaque frame
        }
    }

    /**
     * Méthode appelée lorsque le game state est changé à "Tutorial"
     * qui est le tutoriel du jeu
     *
     */
    public void startTutorial()
    {
        setBGImage("tutorial1");

        removeObjects(null, 0);
        plateforme = new Plateforme(295.0, 250.0, false);
        mouton = new Mouton("fMouton", 320.0, 150.0, Mouton.Direction.sheepRight);
        moutonTutoriel = new Mouton("eMouton", 250, 400, Mouton.Direction.sheepRight);
        btnMenu = new JGObject("btnMenu", true, 130, 600, 1, "menuButton");
        btnGauche = new JGObject("btnGauche", true, 20, 600, 1, "arrowLeft");
        btnDroit = new JGObject("btnDroit", true, 330, 600, 1, "arrowRight");
        monstre2 = new Monstre(250, 425);
        monstre1 = new Monstre(300, 150);
        bullet = new Bullet(0, 0);

        btnGauche.setGraphic(null);

        tutorialState = 1;
    }

    public void doFrameTutorial()
    {
        if (tutorialState == 1)
        {
            checkCollision(2, 1);
            moveObjects();

            mouton.setGraphic("sheepRight");
            mouton.x = 320;

            moutonTutoriel.y = 375;
            moutonTutoriel.xspeed = 2;

            monstre1.remove();
            monstre2.remove();
            bullet.remove();

            if (moutonTutoriel.xdir == 0)
            {
                moutonTutoriel.changerDirection(Mouton.Direction.sheepRight);

            }
            else if (250 - moutonTutoriel.x > 30)
            {
                moutonTutoriel.changerDirection(Mouton.Direction.sheepRight);

            }
            else if (250 - moutonTutoriel.x < -30)
            {
                moutonTutoriel.changerDirection(Mouton.Direction.sheepLeft);

            }
        }
        else if (tutorialState == 2)
        {
            checkCollision(3, 4);
            moveObjects();

            mouton.setGraphic("sheepDead");

            mouton.x = 250;
            mouton.y = 200;

            monstre1.x = 250;
            monstre1.y = 150;
            monstre1.setGraphic("monster");

            moutonTutoriel.x = 300;
            moutonTutoriel.y = 450;
            moutonTutoriel.setGraphic("sheepRight");

            monstre2.x = 300;
            monstre2.y = 350;

            compteurMonstre++;

            if (compteurMonstre == 75)
            {
                bullet = new Bullet(moutonTutoriel.x + 10, moutonTutoriel.y);
            }

            if (compteurMonstre == 200)
            {
                compteurMonstre = 0;
                monstre2 = new Monstre(300, 375);
                monstre2.x = 300;
            }
        }

        // Cliquer sur la fleche rouge vers la droite
        if (getKey(KeyRight) || (getMouseButton(1) && getMouseY() >= 600
                && getMouseY() <= (600 + 36) && getMouseX() >= 330 && getMouseX() <= 380))
        {
            if (tutorialState == 1)
            {
                setBGImage(null);
                monstre1 = new Monstre(0, 0);
                monstre2 = new Monstre(0, 0);
                btnGauche.setGraphic("arrowLeft");

                plateforme.setGraphic(null);
                // On reinitialise la souris
                this.clearMouseButton(1);
                this.clearKey(KeyRight);

                setBGImage("tutorial2");
                tutorialState = 2;
                compteurMonstre = 0;
            }
            else if (tutorialState == 2)
            {
                setBGImage(null);
                btnDroit.setGraphic(null);

                monstre1.remove();
                monstre2.remove();
                mouton.remove();
                moutonTutoriel.remove();

                // On reinitialise la souris
                this.clearMouseButton(1);
                this.clearKey(KeyRight);

                setBGImage("tutorial3");
                tutorialState = 3;
            }
        }

        // Cliquer sur la fleche rouge vers la gauche
        if (getKey(KeyLeft) || (getMouseButton(1) && getMouseY() >= 600
                && getMouseY() <= (600 + 36) && getMouseX() >= 20 && getMouseX() <= 70))
        {
            if (tutorialState == 2)
            {
                setBGImage(null);
                btnGauche.setGraphic(null);

                mouton.setGraphic("sheepRight");
                plateforme.setGraphic("platform");

                // On reinitialise la souris
                this.clearMouseButton(1);
                this.clearKey(KeyLeft);

                mouton.y = 150;
                mouton.ydir = 1;
                setBGImage("tutorial1");
                tutorialState = 1;
            }
            else if (tutorialState == 3)
            {
                setBGImage(null);
                monstre1 = new Monstre(0, 0);
                monstre2 = new Monstre(0, 0);
                btnDroit.setGraphic("arrowRight");

                mouton = new Mouton("fMouton", 320.0, 150.0, Mouton.Direction.sheepRight);
                moutonTutoriel = new Mouton("eMouton", 250, 400, Mouton.Direction.sheepRight);

                // On reinitialise la souris
                this.clearMouseButton(1);
                this.clearKey(KeyLeft);

                setBGImage("tutorial2");
                tutorialState = 2;
                compteurMonstre = 0;
            }
        }

        // Cliquer sur menu
        if ((getMouseButton(1) && getMouseY() >= 600 && getMouseY() <= (600 + 37)
                && getMouseX() >= 135 && getMouseX() <= 400 - 135))
        {
            setBGImage(null);

            // On retire tous les objets dans la fenetre
            removeObjects(null, 0);
            setBGImage(null);

            // On reinitialise la souris
            this.clearMouseButton(1);

            // On reinitialise l'etat de jeu pour ensuite le placer en mode "Menu"
            this.clearGameState();

            setGameState("Menu");
        }
    }

    /**
     * Methode qui permet d'initialiser la plateforme de jeu
     */
    public void startStarted()
    {
        // On place l'arriere plan 
        back = new Background("background", 0, -2580 + 645, "background");
        for (int i = 0; i < 50; i++)
        {
            backPosY -= 645;
            backR.add(new Background("backR", 0, backPosY, "backR"));
        }

        // On active le "wrapping" qui permet d'avancer le mouton vers le haut
        // indefiniment
        setPFWrap(true, true, 25, 35);
        setPFSize(2, 10000);
        xPlage2 = getWidth() - 84;

        // On cree un joueur principal avec la direction droite par defaut
        mouton = new Mouton("zMouton", 175, getHeight() / 2, Mouton.Direction.sheepRight);

        // On cree la premiere plateforme aleatoire
        platArray.add(new Plateforme(155, 600, false));
        coordX = platArray.get(0).getCoordX();
        coordY = platArray.get(0).getCoordY();
        objectCount++;
        objectCountTot++;
    }

    /**
     * Methode appelee a chaque frame lorsque le jeu est en mode "Started"
     */
    public void doFrameStarted()
    {
        // Si le nombre de plateformes presentes dans le jeu est plus petit que 30
        if (objectCount < MAXPLATEFORMS)
        {
            // On rajoute des plateformes et des monstres de façon aléatoire
            randomPlateforme();
        }

        removePlateforme();
        removeObjects(monstreArray);
        removeBullet();
        removeSmoke();
        removeObjects(ressortArray);
        removeObjects(jetPackArray);

        if (objectCountTot % MAXPLATEFORMS == 0 && objectCountTot != lastCount)
        {
            if (yDiff2 < 165)
            {
                yDiff2 += 5;
            }
            if (yDiff < 140)
            {
                yDiff += 5;
            }
            if (xPlage2 > getWidth() / 2)
            {
                xPlage2 -= 15;
            }
            if (xPlage < getWidth() / 2 + 20)
            {
                xPlage += 15;
            }
            if (monstreDiff > 10)
            {
                monstreDiff -= 5;
            }
            if (jetPackDiff < 80)
            {
                jetPackDiff += 5;
            }

            lastCount = objectCountTot;
            objets = true;
        }

        // On commence a verifier les collisions seulement si le mouton n'a pas
        // de jet pack
        if (!mouton.isJetpack())
        {
            // On verifie les collisions entre le mouton et les plateformes
            checkCollision(2, 1);

            // On verifie les collisions entre le mouton et le monstre
            checkCollision(1, 3);

            // On verifie les collisions entre les balles et les monstres
            checkCollision(3, 4);

            // On verifie les collisions entre le mouton et les jetpacks
            checkCollision(1, 5);

            // On verifie les collisions entre le mouton et les ressorts
            checkCollision(1, 6);
        }

        // Si le mouton est vivant, on peut le controler
        if (mouton.isAlive())
        {
            // Si le bouton de gauche est appuye
            if (getKey(KeyLeft))
            {
                if (mouton.isJetpack())
                {
                    mouton.changerDirection(Mouton.Direction.sheepJetPackLeft);
                }
                else
                {
                    // On change la direction du mouton vers la gauche
                    mouton.changerDirection(Mouton.Direction.sheepLeft);
                }
            } // Si le bouton de droite est appuye
            else if (getKey(KeyRight))
            {
                if (mouton.isJetpack())
                {
                    mouton.changerDirection(Mouton.Direction.sheepJetPackRight);

                }
                else
                {
                    // On change le mouton de direction vers la droite
                    mouton.changerDirection(Mouton.Direction.sheepRight);
                }
            } // Si aucune des directions n'est appuyee
            else
            {
                // Le mouton doit aller tout droit vers le haut
                mouton.changerDirection(Mouton.Direction.defaut);
            }

            // Si le bouton CTRL est appuye
            if (getKey(KeyCtrl) && mouton.isAlive() && !mouton.isJetpack())
            {
                // On lance une balle
                playAudio("shooting");
                bulletArray.add(new Bullet(mouton.x + 10, mouton.y));
                this.clearKey(KeyCtrl);
            }
        } // Si le mouton est mort
        else
        {
            // On ne peut plus le bouger et il descend tout droit
            mouton.xdir = 0;
        }

        // Permet de bouger les objets presents dans le frame
        moveObjects();

        if (mouton.y > dernierOffset + 645)
        {
            mouton.setAlive(false);
        }

        if (mouton.isAlive())
        {
            // Calcul du offset selon la position du mouton
            yOfs = ((int) mouton.y - viewHeight() / 2);

            // Si le mouton est au dessus de la moitie de l'ecran
            if (mouton.y <= dernierOffset + viewHeight() / 2)
            {
                // On applique le offset pour "scroll"

                if (mouton.isJetpack())
                {
                    backScrollSpeed += 0.2;
                }
                else
                {
                    backScrollSpeed += 0.1;
                }
                backMove = yOfs + backScrollSpeed;

                back.setPos(0, (-2580 + 645) + yOfs + backScrollSpeed);
                backPosY = -2580 + 645;
                for (int i = 0; i < backR.size(); i++)
                {
                    backPosY -= 645;
                    backR.get(i).setPos(0, (backPosY) + yOfs + backScrollSpeed);
                }
                setViewOffset(xOfs, yOfs, false);

                score++;

                // On sauvegarde le offset pour future comparaison
                dernierOffset = yOfs;
                diePos = dernierOffset + 625;
            }
        }
        else
        {
            if (gagne)
            {
                playAudio("youLose");
                gagne = false;
            }

            if (backScrollSpeed < 645)
            {
                setGameState("End");
            }
            else
            {

                if (diePos > dernierOffset)
                {
                    setViewOffset(xOfs, dernierOffset += 15, false);
                }
                else
                {
                    setGameState("End");
                }
            }
        }

        if (mouton.isJetpack())
        {
            smoke();
            compteurSmoke++;
        }
        else
        {
            compteurSmoke = 0;
        }
    }

    public void paintFrameStarted()
    {
        setColor(JGColor.black);
        drawString("Score: " + score, 390, 630, 1, new JGFont("Courier",
                Font.BOLD, 16), JGColor.black);
    }

    @Override
    public void doFrame()
    {
        if (getLastKeyChar() == 'm')
        {
            if (audioOn)
            {
                disableAudio();
            }
            else
            {
                enableAudio();
            }

            audioChange = true;
            audioOn = !audioOn;
            clearLastKey();
        }
        else if (getLastKeyChar() == 'r')
        {

            clearGameState();
            back.setPos(0, (-2580 + 645));
            backPosY = -2580 + 645;
            for (int i = 0; i < backR.size(); i++)
            {
                backPosY -= 645;
                backR.get(i).setPos(0, (backPosY) - backMove);
            }
            removeObjects(null, 0);

            bulletArray.removeAll(bulletArray);
            monstreArray.removeAll(monstreArray);
            jetPackArray.removeAll(jetPackArray);
            backR.removeAll(backR);
            gagne = true;
            platArray.removeAll(platArray);
            ressortArray.removeAll(ressortArray);
            score = 0;
            smokeArray.removeAll(smokeArray);
            diePos = 0;
            backScrollSpeed = 0;
            dernierOffset = 0;
            monstreDiff = 40;
            jetPackDiff = 60;
            backPosY = -2580 + 645;
            lastCount = 0;


            objectCount = 0;
            yDiff = 30;
            yDiff2 = 90;
            xPlage = 0;
            objectCountTot = 0;
            objets = false;

            tutorialState = 1;
            compteurMonstre = 0;
            compteurSmoke = 0;
            setPFWrap(false, false, 0, 0);
            setPFSize(1, 1);
            yOfs = 0;
            setViewOffset(0, 0, true);

            new JGTimer(10, true)
            {

                @Override
                public void alarm()
                {
                    setGameState("Menu");
                }
            };
            clearLastKey();
        }
    }

    @Override
    public void paintFrame()
    {
        if (audioChange)
        {
            clearLastKey();
            if (audioOn)
            {
                drawString("SOUND ON", viewWidth() / 2, viewHeight() / 2, 0,
                        new JGFont("Courier", Font.BOLD, 16), JGColor.white);
            }
            else
            {
                drawString("SOUND OFF", viewWidth() / 2, viewHeight() / 2, 0,
                        new JGFont("Courier", Font.BOLD, 16), JGColor.white);
            }
            new JGTimer(50, true)
            {

                @Override
                public void alarm()
                {
                    audioChange = false;
                }
            };
        }
    }

    public void paintFrameEnd()
    {
        drawString("Vous avez perdu!", viewWidth() / 2, viewHeight() / 2, 0,
                new JGFont("Courier", Font.BOLD, 26), JGColor.red);
        moveObjects();
        if (continuer)
        {
            new JGTimer(300, true)
            {

                @Override
                public void alarm()
                {
                    clearGameState();
                    setGameState("EnterHighScore");
                    continuer = !continuer;
                }
            };
        }
    }

    public void startEnterHighScore()
    {
        clearLastKey();
        removeObjects("plateforme", 2);
        removeObjects("wmonstre", 3);
        removeObjects("jetPack", 5);
        removeObjects("ressort", 6);
    }

    public void doFrameEnterHighScore()
    {
//        char key = getLastKeyChar();
//        
//        if (key == KeyBackspace && nomJoueur.length() > 0)
//        {
//            nomJoueur = nomJoueur.substring(0, nomJoueur.length() - 1);
//        }
//        
//        if (key == KeyEnter)
//        {
////			highscores = Highscore.insert(highscores,
////					new Highscore(score,playername));
//            clearLastKey();
//            clearKey(KeyEnter);
//            saveHighScores();
//            setGameState("Highscores");
//        }
//        if (key >= 32 && key < 127 && nomJoueur.length() < 25)
//        {
//            nomJoueur += key;
//        }
//        clearLastKey();
    }

    public void paintFrameEnterHighScore()
    {
        drawString("Votre score est de: ", viewWidth() / 2, viewHeight() / 3, 0,
                new JGFont("Courier", Font.BOLD, 26), JGColor.red);
        drawString("" + score, viewWidth() / 2, viewHeight() / 2, 0,
                new JGFont("Courier", Font.BOLD, 26), JGColor.red);
//        drawString(nomJoueur + "|", viewWidth() / 2, 2 * viewHeight() / 3, 0,
//                new JGFont("Courier", Font.BOLD, 26), JGColor.red);
    }

    /**
     * Methode qui genere des plateformes de facon aleatoire
     */
    public void randomPlateforme()
    {
        for (int i = objectCount; i < MAXPLATEFORMS; i++)
        {
            if (coordX < getWidth() / 2 - 84)
            {
                xAleatoire = random(xPlage, (getWidth() - 84));
            }
            else
            {
                xAleatoire = random(0, xPlage2);
            }
            platArray.add(new Plateforme(xAleatoire,
                    random((coordY - yDiff), (coordY - yDiff2)), true));
            objectCountTot++;
            coordX = platArray.get(i).getCoordX();
            coordY = platArray.get(i).getCoordY();
            if (objets && !mouton.isJetpack() && !platArray.get(i).isMoving())
            {
                randomMonstre();
                randomJetPack();
                randomRessort();

                creerObjet = true;
            }

            objectCount++;
        }
    }

    /**
     * Methode qui genere des monstres de facon aleatoire
     */
    public void randomMonstre()
    {
        double randomNombre = random(0, monstreDiff);
        if (randomNombre > 5 && randomNombre < 6)
        {
            playAudio("spawn");
            monstreArray.add(new Monstre(0, random(dernierOffset - 645, dernierOffset - 10)));
        }
    }

    /**
     * Methode qui genere des jetpacks de facon aleatoire
     */
    public void randomJetPack()
    {
        if (creerObjet)
        {
            double randomNombre = random(0, jetPackDiff);
            if (randomNombre > 5 && randomNombre < 6)
            {
                jetPackArray.add(new JetPack(coordX + 25, coordY - 48));
                creerObjet = false;
            }
        }
    }

    /**  n
     * Methode qui genere des ressorts de facon aleatoire
     */
    public void randomRessort()
    {
        if (creerObjet)
        {
            double randomNombre = random(0, 20);
            if (randomNombre > 5 && randomNombre < 6)
            {
                ressortArray.add(new Ressort(coordX + 20, coordY - 15));
                creerObjet = false;
            }
        }
    }

    /**
     * Methode appelee a chaque frame pour retirer les plateformes hors champs
     */
    public void removePlateforme()
    {
        for (int i = 0; i < platArray.size(); i++)
        {
            if (platArray.get(i).y > dernierOffset + 645)
            {
                removeObject(platArray.get(i));
                platArray.remove(i);
                objectCount--;
            }
        }
    }

    /**
     * Méthode qui rnlève les objets inutiles
     */
    public void removeObjects(ArrayList<JGObject> objetsG)
    {
        for (int i = 0; i < objetsG.size(); i++)
        {
            if (objetsG.get(i).y > dernierOffset + 645)
            {
                removeObject(objetsG.get(i));
                objetsG.get(i).remove();
                objetsG.remove(i);
            }
        }
    }

    /**
     * Enlève les balles quand elles sont hors champ
     */
    public void removeBullet()
    {
        for (int i = 0; i < bulletArray.size(); i++)
        {
            if (!bulletArray.get(i).isInView(0, -20))
            {
                removeObject(bulletArray.get(i));
                bulletArray.get(i).remove();
                bulletArray.remove(i);
            }
        }
    }

    public void smoke()
    {
        if (compteurSmoke % 5 == 0)
        {
            if (mouton.getGraphic().equals("sheepJetPackLeft"))
            {
                smokeArray.add(new Smoke((mouton.x + 30 - random(-10, 10)), (mouton.y + 55)));

            }
            else if (mouton.getGraphic().equals("sheepJetPackRight"))
            {
                smokeArray.add(new Smoke((mouton.x - random(-10, 10)), (mouton.y + 55)));
            }
        }
    }

    public void removeSmoke()
    {
        for (int i = 0; i < smokeArray.size(); i++)
        {
            if (smokeArray.get(i).y > dernierOffset + 550)
            {
                removeObject(smokeArray.get(i));
                smokeArray.get(i).remove();
                smokeArray.remove(i);
            }
        }
    }
}
